package com.hzsoft.util;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringUtils;

public class StrUtil {
	/**
	 * 拆分::字符串(单组)
	 */
	public static String[] getParm(String str) {
		return str.split("::");
	}

	/**
	 * 判断是否是数字，不包括小数点。
	 * @param str  输入的字符串
	 */
	public static boolean isNum(String str) {
		return StringUtils.isNumeric(str);
	}

	/**
	 * 判断是否是数字，包含小数点。
	 * 
	 * @param str
	 *            判断的字符串
	 */
	public static boolean isNumber(String str) {
		return StringUtils.isNumeric(str.replace(".", ""));
	}

	/**
	 * 判断是否是数字，包括小数和E.
	 * 
	 * @param ch 输入字符串
	 */
	public static boolean isNumeric(Object ch) {
		if (ch == null)
			return false;
		boolean b_fig = false;

		try {
			String s = ch.toString();
			String str_regexfig = "\\d+.?\\d+E?\\d+"; // 匹配数字或小数
			Pattern p_fig = Pattern.compile(str_regexfig);
			Matcher m_fig = p_fig.matcher(s);
			b_fig = m_fig.matches();
		} catch (Exception e) {
			return false;
		}
		return b_fig;
	}

	/**
	 * 根据tag参数提取字符串中的子字符串,返回一个字符串 用来截取只出现一次目标字符串，如果出现多次将截取最左边一个目标字符串。
	 * 如果要截取多个请使用重载方法 findBetween(String str, String open, String close)
	 * 
	 * @param str
	 *            目标字符串
	 * @param tag
	 *            标志字符串
	 * @return 提取的字符串
	 */
	public static String findBetween(String str, String tag) {
		return StringUtils.substringBetween(str, tag);
	}

	/**
	 * 根据开始字符串open,和结束字符串close提取字符串为一个数组
	 * 
	 * @param str
	 *            目标字符串
	 * @param open
	 *            开始字符串
	 * @param close
	 *            关闭字符串
	 */
	public static String[] findBetween(String str, String open, String close) {
		return StringUtils.substringsBetween(str, open, close);
	}

	/**
	 * 根据开始字符串open,和结束字符串close提取字符串为一个字符串
	 * 
	 * @param str
	 *            目标字符串
	 * @param open
	 *            开始字符串
	 * @param close
	 *            关闭字符串
	 */
	public static String findBetweenStr(String str, String open, String close) {
		return StringUtils.substringBetween(str, open, close);
	}

	/**
	 * 将给定的字符串参数返回特定格式
	 * 
	 * @param parStr
	 *            输入格式前字符串 例如: [370661900]=[烟台市分行信用卡中心],[370665000]=[烟台芝罘湾支行]
	 * @return 370661900,370665000
	 */
	public static String getSqlParameter1(String parStr) {
		String[] tempArray = findBetween(parStr, "[", "]");
		StringBuffer endStr = new StringBuffer();
		for (String xx : tempArray) {
			if (StrUtil.isNum(xx)) {
				endStr.append(xx);
				endStr.append(",");
			}
		}
		return endStr.substring(0, endStr.length() - 1);
	}

	/**
	 * 将字符串转换为指定格式
	 * 
	 * @param parStr
	 *            输入格式前的字符串 例如: 1232::哈哈,322::试试,324::千多的
	 * @return '1232','322','324'
	 */
	public static String getSqlParameter2(String parStr) {
		String[] tempArray = parStr.split(",");
		String[] tp = null;
		StringBuffer sb = new StringBuffer();
		
		for (String xx : tempArray) {
			tp = xx.split("::");
			sb.append("'");
			sb.append(tp[0]);
			sb.append("',");
		}
		return sb.substring(0, sb.length() - 1);
	}

	/**
	 * 将字符串转换为特定格式 例如: 000002001::新和成,000002002::江苏琼花 返回: 新和成,江苏琼花
	 * 
	 * @param parStr
	 *            parStr 将要转换的字符串
	 * @return 转换后的字符串
	 */
	public static String getSqlParameter3(String parStr) {
		if (org.apache.commons.lang3.StringUtils.isEmpty(parStr)) {
			return null;
		}
		String[] tempArray = parStr.split(",");
		String[] tp = null;
		StringBuffer sb = new StringBuffer();
		for (String temp : tempArray) {
			tp = temp.split("::");
			sb.append(tp[1]);
			sb.append(",");
		}
		return sb.substring(0, sb.length() - 1);
	}
	
	/**
	 * 将字符串转换为指定格式
	 * 
	 * @param parStr
	 *            输入格式前的字符串 例如: 1232::哈哈,322::试试,324::千多的
	 * @return 1232,322,324
	 */
	public static String getSqlParameter4(String parStr) {
		String[] tempArray = parStr.split(",");
		String[] tp = null;
		StringBuffer sb = new StringBuffer();
		for (String xx : tempArray) {
			tp = xx.split("::");
			sb.append(tp[0]);
			sb.append(",");
		}
		System.out.println("1232,322,324  --  > "+sb.substring(0, sb.length() - 1));
		return sb.substring(0, sb.length() - 1);
	}

	/**
	 * 将null 转换为 ""
	 * 
	 * @param parStr
	 *            输入的字符串格式
	 * @return
	 */
	public static String getSkystr(String parStr) {
		String Skystr = "";
		if (parStr == null || parStr.equals("")) {
			Skystr = "";
		} else {
			Skystr = parStr;
		}
		return Skystr;
	}

	/**
	 * 将null 转换为 "" 并且类型转换后输出
	 * 
	 * @param parStr
	 * @return
	 */
	public static String getSky1str(String parStr) {
		String Skystr = "";
		if (parStr == null || parStr.equals("")) {
			Skystr = "";
		} else {
			Skystr = StrUtil.getValueData(parStr);
		}
		return Skystr;
	}
	
	/**
	 * 将× 转换成&
	 * @param parsky
	 * @return
	 */
	public static String getStrsky(String parsky){
		String strsky = "";
		if(parsky == null || parsky.equals("")){
			strsky = "";
		}else {

			strsky = parsky.replace("@","&");
			
		}
		return strsky;
	}
	
	/**
	 * 将,替换成空''
	 * @param parsky
	 * @return
	 */
	public static String getStrsky1(String parsky){
		String strsky = "";
		if(parsky == null || parsky.equals("")){
			strsky = "";
		}else {
			strsky = parsky.replace(",","");
		}
		return strsky;
	}

	/**
	 * 将时间类型返回指定的格式
	 * 
	 * @param parStr
	 *            输入格式前的字符串 例如: [2007-01]=[1月],[2007-02]=[2月] return
	 *            '2007-01','2007-02'
	 */
	public static String getdateStr(String parStr) {
		String yearmon = "";
		String[] jj = parStr.split(",");
		for (int i = 0, j = jj.length; i < j; i++) {
			String[] xx = jj[i].split("=");
			yearmon = yearmon + "," + "'" + xx[0].substring(1, 8) + "'";
		}
		return yearmon.substring(1, yearmon.length());
	}

	/**
	 * 将获取出来的double类型转化成String
	 * 
	 * @param parStr
	 *            输入格式前的字符串
	 */
	public static String getValueData(String parStr) {
		if (parStr != null) {
			// DecimalFormat df = new DecimalFormat("0.00");
			Double tempData = new Double(parStr);
			return tempData.toString();
		}
		return "";
	}

	/**
	 * 将获取出来的double类型格式化后转化成String
	 * 
	 * @param parStr
	 *            输入格式前的字符串
	 */
	public static String getnumData(String parStr) {
		if (parStr != null) {
			Double tempData = new Double(parStr);
			String xx = NumberUtil.formatDecimal(tempData);
			return xx;
		}
		return "";
	}

	/**
	 * 将获取出来的double类型精度计算后转化成String
	 * 
	 * @param parStr
	 *            输入格式前的字符串
	 */
	public static String getdivData(String parStr) {
		if (parStr != null) {
			// Double tempData = new Double(parStr);
			String xx = String.valueOf(NumberUtil.div(parStr, "100", 4));
			return xx;
		}
		return "";
	}

	/**
	 * 数组字符串数组转换为xxx,xxx,xxx字符串
	 */
	public static String getArrayString1(String[] parStr) {
		StringBuffer sb = new StringBuffer();
		for (String tempStr : parStr) {
			sb.append(tempStr);
			sb.append(",");
		}
		return sb.toString().substring(0, sb.length() - 1);
	}

	/**
	 * 将字符串数组转换为'xxx','xxx','xxx'字符串
	 */
	public static String getArrayString2(String[] parStr) {
		StringBuffer sb = new StringBuffer();
		for (String tempStr : parStr) {
			sb.append("'");
			sb.append(tempStr);
			sb.append("',");
		}
		return sb.toString().substring(0, sb.length() - 1);
	}
	
	/**
	 * 将字符串数组转换为'xxx','xxx','xxx'字符串
	 */
	public static String getArrayString2(Object[] parStr) {
		StringBuffer sb = new StringBuffer();
		for (Object tempStr : parStr) {
			sb.append("'");
			sb.append(tempStr);
			sb.append("',");
		}
		return sb.toString().substring(0, sb.length() - 1);
	}

	/**
	 * 针对月份在左面添加'0' 例如 8 -> 08
	 * 
	 * @param parString
	 *            月份字符串
	 */
	public static String getPadding(String parString) {
		return getLeftPad(parString, 2, "0");
	}

	/**
	 * 左面填充特定个数的字符串
	 * 
	 * @param parStr
	 *            准备填充的字符串
	 * @param size
	 *            字符串长度
	 * @param padStr
	 *            填充的字符串
	 */
	public static String getLeftPad(String parStr, int size, String padStr) {
		return StringUtils.leftPad(parStr, size, padStr);
	}

	/**
	 * 右面填充特定个数的字符串
	 * 
	 * @param parStr
	 *            准备填充的字符串
	 * @param size
	 *            字符串长度
	 * @param padStr
	 *            填充的字符串
	 */
	public static String getRightPad(String parStr, int size, String padStr) {
		return StringUtils.rightPad(parStr, size, padStr);
	}

	/**
	 * 特殊功能处理方法，翻过特等格式字符串中的一部分 例: {JXXMGS}(@bjyear@,@hy@,@hyfw@,0102,良) 返回 0102良
	 * 
	 * @param parStr
	 *            要处理字符串
	 */
	public static String getSpcString(String parStr) {
		if (StringUtils.isEmpty(parStr)) {
			return null;
		}
		String[] strArray = parStr.split(",");
		String endStr = strArray[3] + strArray[4];
		return endStr.substring(0, endStr.length() - 1);
	}

	/**
	 * 将每个个字段列表加上to_char()函数
	 */
	public static String procStringAddToCharFun(String parStr) {
		if (StringUtils.isEmpty(parStr)) {
			return null;
		}
		String[] tempData = parStr.split(",");
		for (int i = 0; i < tempData.length; i++) {
			tempData[i] = "to_char(" + tempData[i] + ",'999999990.00') as " +tempData[i] ;
		}
		StringBuilder sb = new StringBuilder();
		for (String fd : tempData) {
			sb.append(fd);
			sb.append(",");
		}
		String endStr = sb.toString();
		return endStr.substring(0, endStr.length() - 1);
	}
	
	/**
	 * 将每个个字段列表加上avg(to_char())函数
	 * @param parStr
	 * @return
	 */
	public static String procAvgStrAddToCharFun(String parStr){
		if (StringUtils.isEmpty(parStr)) {
			return null;
		}
		String[] tempData = parStr.split(",");
		for (int i = 0; i < tempData.length; i++) {
			tempData[i] = "to_char( avg(" + tempData[i] + "),'999999990.00') as " + tempData[i];
		}
		StringBuilder sb = new StringBuilder();
		for (String fd : tempData) {
			sb.append(fd);
			sb.append(",");
		}
		String endStr = sb.toString();
		return endStr.substring(0, endStr.length() - 1);
	}

	/**
	 * 查询double 的数据全是 0
	 * @param pardou
	 * @return 如果全是0 为 true ，否则false
	 */
	public boolean getsjfx(double[] pardou) {
		boolean flag = true;
		double[] xx = pardou;
		for (int i = 0; i < xx.length; i++) {
			if (xx[i] != 0) {
				flag = false;
			} else {
				flag = true;
			}
		}
		return flag;
	}
	
	/**
	 * 将指定字符串根据map容器中的字符串替换
	 * @param parStr 要替换的字符串
	 * @param parCo 替换的列表
	 * @return 返回的新字符串
	 */
	public static String allReplace(String parStr, Map<String, String> parCo) {
		if (StringUtils.isEmpty(parStr) || parCo.size() == 0) {
			return null;
		}
		Set<Entry<String, String>> entrySet = parCo.entrySet();
		for (Entry<String, String> entry : entrySet) {
			parStr = parStr.replace(entry.getKey(), entry.getValue());
		}
		return parStr;
	}

	/**
	 * 将字符串转换为数组
	 * [undefined]将自动去除
	 * 例如：undefined,001,00101,00102,00103,00104,002,00201,00202
	 * 返回: {001,00101,00102,00103,00104,002,00201,00202}
	 * @param str 需要转换的字符串
	 * @return 过滤后的数组对象
	 */
	public static String[] funsplit(String str) {
	    String[] tempStrArray = str.split(",");
	    List<String> t = new ArrayList<String>();
	    for (String tempStr : tempStrArray) {
	    	if (!tempStr.equals("undefined")) {
	    		t.add(tempStr);
	    	}
	    }
		String[] b = new String[t.size()];
		for (int i = 0, k = t.size(); i < k; i++) {
			b[i] = t.get(i);
		}
		return b;
	}
	public static String[] funNsplit(String str) {
		String[] tempStrArray = str.split(",");
		List<String> t = new ArrayList<String>();
		for (String tempStr : tempStrArray) {
			if (!tempStr.equals("")) {
				t.add(tempStr);
			}
		}
		String[] b = new String[t.size()];
		for (int i = 0, k = t.size(); i < k; i++) {
			b[i] = t.get(i);
		}
		return b;
	}
	
	/**
	 * 第二个从第一个查找
	 * @param parsplit1  例如 undefined,001,00101,00102,00103,00104,002,00201,00202 
	 * @param parsplitl2	要查询的字符串 001 
	 * @return true
	 */
	public static boolean getsplit(String parsplit1 ,String parsplitl2){
		boolean flag = false;
		String  [] split  = parsplit1.split(",");
		for(int i = 0 ; i < split.length ; i++){
			if(split[i].equals(parsplitl2)){
				flag = true;
			}
		}
		return flag;
	}
	
	/**
	 * 查找数组中没有有重复值 
	 * @return 
	 */
	public static boolean getchazhao(String [] parSZ){
		boolean flag = false;
		out:for(int   i=0;i<parSZ.length;i++){   
		  	for(int   j=i+1;j<parSZ.length;j++){   
		  		if(parSZ[i].equals(parSZ[j])){   
		  			flag=true;   
		  			break   out;   
		  		}
		  	}   
		}   
		return flag;
	}
	
	/**
	 * 判断数组中的值是不是全部相等
	 * @return 
	 */
	public static boolean getchazhao1(String [] parSZ){
		boolean flag = true;
		out:for(int   i=0;i<parSZ.length;i++){   
		  	for(int   j=i+1;j<parSZ.length;j++){   
		  		if(parSZ[i].equals(parSZ[j])==false){   
		  			flag=false;   
		  			break   out;   
		  		}
		  	}   
		}   
		return flag;
	}

	/**
	 * 将字符串数组转换为111,222,333的字符串
	 * @param parArray 字符数组
	 * @return 转换后的字符串
	 */
	public static String arrayToString(String[] parArray) {
		return StrUtil.findBetweenStr(ArrayUtils.toString(parArray), "{", "}");
	}
	
	/**
	 * 将对象数组转换为111,222,333的字符串
	 * @param parArray 字符数组
	 * @return 转换后的字符串
	 */
	public static String arrayToString(Object[] parArray) {
		return StrUtil.findBetweenStr(ArrayUtils.toString(parArray), "{", "}");
	}
	
	/**
	 * 根据Value返回运算符
	 * @param parId 编号
	 */
	public static String getExpValue(String parId) {
		if ("1".equals(parId)) {
			return " > ";
		}
		if ("2".equals(parId)) {
			return " < ";
		}
		if ("3".equals(parId)) {
			return " = ";
		}
		if ("4".equals(parId)) {
			return " >= ";
		}
		if ("5".equals(parId)) {
			return " <= ";
		}
		return " ";
	}
	

	
	/**
	 * 将字符串转换为BigDecimal
	 * @param parStr 字符串
	 */
	public static BigDecimal strToDecimal(String parStr) {
		if (StringUtils.isEmpty(parStr)) {
			return null;
		}
		else {
			return new BigDecimal(parStr);
		}
	}
	
	/**
	 * 将字符串111,222,333元素添加单引号'111','222','333'
	 * @param parStr 处理的字符串
	 */
	public static String getStringArray(String parStr) {
		if (StringUtils.isEmpty(parStr)) {
			return null;
		}
		String[] checkDataArray = parStr.split(",");
		String aduStr = "";
		if(checkDataArray!=null && checkDataArray.length > 0) {
			for(int i = 0 ; i <checkDataArray.length ; i++){
				aduStr += "'"+checkDataArray[i].trim()+"',";
			}
		}
		aduStr =  aduStr.substring(0,aduStr.length()-1);
		return aduStr;
	}
	
	/**
	 * 在字符串数组中查找是否存在某个字符串
	 * @param findValue 要查找的值
	 * @param baseArray 搜索的字符串数组
	 */
	public static boolean searchEleFromArray(String findValue, String[] baseArray) {
		boolean flag = false;
		for (String element : baseArray) {
			if (findValue.equals(element)) {
				flag = true;
				break;
			}
		}
		return flag;
	}
	
	public static void main(String... args) {
		// System.out.println(" assa -> [" + StrUtil.trim(" assa ") + "]");
		// System.out.println(" abcd e fghi -> [" + StrUtil.clear(" abcd e fghi
		// ") + "]");
		// System.out.println("null -> [" + StrUtil.trim(null) + "]");
		// System.out.println("12.3 -> [" + StrUtil.isNumeric("12.2E3") + "]");
		// System.out.println("abcAAAAAabcVVVVVabc -> [" +
		// StrUtil.findBetween("abcAAAAAabcVVVVVabc", "abc") + "]");
		// System.out.print("abcAAAAAabcabcVVVVVabc -> [");
		// String[] ss = StrUtil.findBetween("abcAAAAAabcabcVVVVVabc", "abc",
		// "abc");
		// for (String xx : ss) {
		// System.out.print(" " + xx);
		// }
		// System.out.println(" ]");

		// System.out.println(StrUtil.getSqlParameter1("[370661900]=[烟台市分行信用卡中心],[370665000]=[烟台芝罘湾支行],[370665100]=[烟台白石路办事处],[370665200]=[烟台西郊办事处]"));
		// System.out.println(StrUtil.getSqlParameter1("[370661900]=[烟台市分行信用卡中心],[370665000]=[烟台芝罘湾支行]"));
		// System.out.println(StrUtil.getSqlParameter2("1232::哈哈,322::试试,324::千多的"));
		// System.out.println(StrUtil.getSqlParameter2("1232::哈哈"));
		// System.out.println(StrUtil.getdateStr("[2000-11]=[11月]"));
		// Double xx = new Double(".123");
		// System.out.println(xx.toString());
		// System.out.println(getValueData(".236"));
		// System.out.println(StrUtil.isNumeric(".365"));
		// System.out.println(StrUtil.isNumber(".23"));
		// String[] temp = {"111", "222"};
		// System.out.println(StrUtil.getArrayString1(temp));
		// String[] xxxx = {"111", "222"};
		// System.out.println(StrUtil.getArrayString2(xxxx));
		// System.out.println(StrUtil.getLeftPad("哈哈", 6, "A"));
		// System.out.println(StrUtil.getPadding("12"));
		// System.out.println(StrUtil.getSqlParameter3("000002001::新和成,000002002::江苏琼花"));
		// System.out.println(StrUtil.getRightPad("你哈", 20, "&nbsp;"));
		// System.out.println(StrUtil.getSpcString("{JXXMGS}(@bjyear@,@hy@,@hyfw@,0102,良)"));
		// System.out.println(StrUtil.getSqlParameter2("2000032"));
		// System.out.println(StrUtil.procStringAddToCharFun("aaa,bbb,ccc"));
		//String testStr = "你好中国，北京2008，哈哈China";
		//Map<String, String> replaceMapData = new HashMap<String, String>();
		//replaceMapData.put("中国", "奥林匹克");
		//replaceMapData.put("哈哈", "Welcome to ");
		//System.out.println(StrUtil.allReplace(testStr, replaceMapData));
		//System.out.println(StrUtil.arrayToString(new String[] {"aaa","bbb"}) );
		//String slp="undefined,001,00101,00102,00103,00104,002,00201,00202";
		//String xx = "0001";
		//System.out.println(StrUtil.getsplit(slp, xx));
		//System.out.println(StrUtil.strToDecimal("12345678"));
	    //String testStr = "你好中国，北京2008，哈哈China";
		//Map<String, String> replaceMapData = new HashMap<String, String>();
		//replaceMapData.put("中国", "奥林匹克");
		//replaceMapData.put("哈哈", "Welcome to ");
		//System.out.println(StrUtil.allReplace(testStr, replaceMapData));
	    //System.out.println(StrUtil.arrayToString(new String[]{"111","222"}));
		//System.out.println(StrUtil.getStringArray("111"));
		//String[] aa = {"111", "222", "333", "444"};
		//System.out.println(StrUtil.searchEleFromArray("aaa", aa));
	}
}


